+Thu Jul 16 18:24:41 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtknotebook.h:
+ * gtk/gtknotebook.c: signdness corrections all ove the place.
+ implementation of object arguments: GtkNotebook::enable_popup,
+ GtkNotebook::tab_pos, GtkNotebook::tab_border, GtkNotebook::show_tabs,
+ GtkNotebook::show_border, GtkNotebook::scrollable and GtkNotebook::page.
+ begun implementation of child args, we have GtkNotebook::tab_label, but
+ GtkNotebook::menu_label and GtkNotebook::position still lack the
+ implementation.
+ (gtk_notebook_remove_page):
+ (gtk_notebook_current_page): allow negative indices (-1) as alias for
+ the last page.
+
+ * gtk/gtkentry.h:
+ * gtk/gtkentry.c: GtkType and macro fixups. implementation of object
+ arguments GtkEntry::max_length and GtkEntry::visibility.
+ (gtk_entry_adjust_scroll): queue a redraw.
+
+ * gtk/gtkeditable.h:
+ * gtk/gtkeditable.c: GtkType und macro fixups. implementation of
+ object arguments GtkEditable::text_position and GtkEditable::editable.
+ new (action) signal GtkEditable::set_editable.
+ provide a default handler for GtkEditable::changed that queues a redraw.
+
+ * gtk/gtktext.h:
+ * gtk/gtktext.c: GtkType und macro fixups. override GtkEditable::
+ set_editable.
+
Thu Jul 16 14:42:11 1998 Lars Hamann <lars@gtk.org>
* gtk/gtkctree.c (gtk_ctree_button_release): fix for sigsegv in
+Thu Jul 16 18:24:41 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtknotebook.h:
+ * gtk/gtknotebook.c: signdness corrections all ove the place.
+ implementation of object arguments: GtkNotebook::enable_popup,
+ GtkNotebook::tab_pos, GtkNotebook::tab_border, GtkNotebook::show_tabs,
+ GtkNotebook::show_border, GtkNotebook::scrollable and GtkNotebook::page.
+ begun implementation of child args, we have GtkNotebook::tab_label, but
+ GtkNotebook::menu_label and GtkNotebook::position still lack the
+ implementation.
+ (gtk_notebook_remove_page):
+ (gtk_notebook_current_page): allow negative indices (-1) as alias for
+ the last page.
+
+ * gtk/gtkentry.h:
+ * gtk/gtkentry.c: GtkType and macro fixups. implementation of object
+ arguments GtkEntry::max_length and GtkEntry::visibility.
+ (gtk_entry_adjust_scroll): queue a redraw.
+
+ * gtk/gtkeditable.h:
+ * gtk/gtkeditable.c: GtkType und macro fixups. implementation of
+ object arguments GtkEditable::text_position and GtkEditable::editable.
+ new (action) signal GtkEditable::set_editable.
+ provide a default handler for GtkEditable::changed that queues a redraw.
+
+ * gtk/gtktext.h:
+ * gtk/gtktext.c: GtkType und macro fixups. override GtkEditable::
+ set_editable.
+
Thu Jul 16 14:42:11 1998 Lars Hamann <lars@gtk.org>
* gtk/gtkctree.c (gtk_ctree_button_release): fix for sigsegv in
+Thu Jul 16 18:24:41 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtknotebook.h:
+ * gtk/gtknotebook.c: signdness corrections all ove the place.
+ implementation of object arguments: GtkNotebook::enable_popup,
+ GtkNotebook::tab_pos, GtkNotebook::tab_border, GtkNotebook::show_tabs,
+ GtkNotebook::show_border, GtkNotebook::scrollable and GtkNotebook::page.
+ begun implementation of child args, we have GtkNotebook::tab_label, but
+ GtkNotebook::menu_label and GtkNotebook::position still lack the
+ implementation.
+ (gtk_notebook_remove_page):
+ (gtk_notebook_current_page): allow negative indices (-1) as alias for
+ the last page.
+
+ * gtk/gtkentry.h:
+ * gtk/gtkentry.c: GtkType and macro fixups. implementation of object
+ arguments GtkEntry::max_length and GtkEntry::visibility.
+ (gtk_entry_adjust_scroll): queue a redraw.
+
+ * gtk/gtkeditable.h:
+ * gtk/gtkeditable.c: GtkType und macro fixups. implementation of
+ object arguments GtkEditable::text_position and GtkEditable::editable.
+ new (action) signal GtkEditable::set_editable.
+ provide a default handler for GtkEditable::changed that queues a redraw.
+
+ * gtk/gtktext.h:
+ * gtk/gtktext.c: GtkType und macro fixups. override GtkEditable::
+ set_editable.
+
Thu Jul 16 14:42:11 1998 Lars Hamann <lars@gtk.org>
* gtk/gtkctree.c (gtk_ctree_button_release): fix for sigsegv in
+Thu Jul 16 18:24:41 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtknotebook.h:
+ * gtk/gtknotebook.c: signdness corrections all ove the place.
+ implementation of object arguments: GtkNotebook::enable_popup,
+ GtkNotebook::tab_pos, GtkNotebook::tab_border, GtkNotebook::show_tabs,
+ GtkNotebook::show_border, GtkNotebook::scrollable and GtkNotebook::page.
+ begun implementation of child args, we have GtkNotebook::tab_label, but
+ GtkNotebook::menu_label and GtkNotebook::position still lack the
+ implementation.
+ (gtk_notebook_remove_page):
+ (gtk_notebook_current_page): allow negative indices (-1) as alias for
+ the last page.
+
+ * gtk/gtkentry.h:
+ * gtk/gtkentry.c: GtkType and macro fixups. implementation of object
+ arguments GtkEntry::max_length and GtkEntry::visibility.
+ (gtk_entry_adjust_scroll): queue a redraw.
+
+ * gtk/gtkeditable.h:
+ * gtk/gtkeditable.c: GtkType und macro fixups. implementation of
+ object arguments GtkEditable::text_position and GtkEditable::editable.
+ new (action) signal GtkEditable::set_editable.
+ provide a default handler for GtkEditable::changed that queues a redraw.
+
+ * gtk/gtktext.h:
+ * gtk/gtktext.c: GtkType und macro fixups. override GtkEditable::
+ set_editable.
+
Thu Jul 16 14:42:11 1998 Lars Hamann <lars@gtk.org>
* gtk/gtkctree.c (gtk_ctree_button_release): fix for sigsegv in
+Thu Jul 16 18:24:41 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtknotebook.h:
+ * gtk/gtknotebook.c: signdness corrections all ove the place.
+ implementation of object arguments: GtkNotebook::enable_popup,
+ GtkNotebook::tab_pos, GtkNotebook::tab_border, GtkNotebook::show_tabs,
+ GtkNotebook::show_border, GtkNotebook::scrollable and GtkNotebook::page.
+ begun implementation of child args, we have GtkNotebook::tab_label, but
+ GtkNotebook::menu_label and GtkNotebook::position still lack the
+ implementation.
+ (gtk_notebook_remove_page):
+ (gtk_notebook_current_page): allow negative indices (-1) as alias for
+ the last page.
+
+ * gtk/gtkentry.h:
+ * gtk/gtkentry.c: GtkType and macro fixups. implementation of object
+ arguments GtkEntry::max_length and GtkEntry::visibility.
+ (gtk_entry_adjust_scroll): queue a redraw.
+
+ * gtk/gtkeditable.h:
+ * gtk/gtkeditable.c: GtkType und macro fixups. implementation of
+ object arguments GtkEditable::text_position and GtkEditable::editable.
+ new (action) signal GtkEditable::set_editable.
+ provide a default handler for GtkEditable::changed that queues a redraw.
+
+ * gtk/gtktext.h:
+ * gtk/gtktext.c: GtkType und macro fixups. override GtkEditable::
+ set_editable.
+
Thu Jul 16 14:42:11 1998 Lars Hamann <lars@gtk.org>
* gtk/gtkctree.c (gtk_ctree_button_release): fix for sigsegv in
+Thu Jul 16 18:24:41 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtknotebook.h:
+ * gtk/gtknotebook.c: signdness corrections all ove the place.
+ implementation of object arguments: GtkNotebook::enable_popup,
+ GtkNotebook::tab_pos, GtkNotebook::tab_border, GtkNotebook::show_tabs,
+ GtkNotebook::show_border, GtkNotebook::scrollable and GtkNotebook::page.
+ begun implementation of child args, we have GtkNotebook::tab_label, but
+ GtkNotebook::menu_label and GtkNotebook::position still lack the
+ implementation.
+ (gtk_notebook_remove_page):
+ (gtk_notebook_current_page): allow negative indices (-1) as alias for
+ the last page.
+
+ * gtk/gtkentry.h:
+ * gtk/gtkentry.c: GtkType and macro fixups. implementation of object
+ arguments GtkEntry::max_length and GtkEntry::visibility.
+ (gtk_entry_adjust_scroll): queue a redraw.
+
+ * gtk/gtkeditable.h:
+ * gtk/gtkeditable.c: GtkType und macro fixups. implementation of
+ object arguments GtkEditable::text_position and GtkEditable::editable.
+ new (action) signal GtkEditable::set_editable.
+ provide a default handler for GtkEditable::changed that queues a redraw.
+
+ * gtk/gtktext.h:
+ * gtk/gtktext.c: GtkType und macro fixups. override GtkEditable::
+ set_editable.
+
Thu Jul 16 14:42:11 1998 Lars Hamann <lars@gtk.org>
* gtk/gtkctree.c (gtk_ctree_button_release): fix for sigsegv in
+Thu Jul 16 18:24:41 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtknotebook.h:
+ * gtk/gtknotebook.c: signdness corrections all ove the place.
+ implementation of object arguments: GtkNotebook::enable_popup,
+ GtkNotebook::tab_pos, GtkNotebook::tab_border, GtkNotebook::show_tabs,
+ GtkNotebook::show_border, GtkNotebook::scrollable and GtkNotebook::page.
+ begun implementation of child args, we have GtkNotebook::tab_label, but
+ GtkNotebook::menu_label and GtkNotebook::position still lack the
+ implementation.
+ (gtk_notebook_remove_page):
+ (gtk_notebook_current_page): allow negative indices (-1) as alias for
+ the last page.
+
+ * gtk/gtkentry.h:
+ * gtk/gtkentry.c: GtkType and macro fixups. implementation of object
+ arguments GtkEntry::max_length and GtkEntry::visibility.
+ (gtk_entry_adjust_scroll): queue a redraw.
+
+ * gtk/gtkeditable.h:
+ * gtk/gtkeditable.c: GtkType und macro fixups. implementation of
+ object arguments GtkEditable::text_position and GtkEditable::editable.
+ new (action) signal GtkEditable::set_editable.
+ provide a default handler for GtkEditable::changed that queues a redraw.
+
+ * gtk/gtktext.h:
+ * gtk/gtktext.c: GtkType und macro fixups. override GtkEditable::
+ set_editable.
+
Thu Jul 16 14:42:11 1998 Lars Hamann <lars@gtk.org>
* gtk/gtkctree.c (gtk_ctree_button_release): fix for sigsegv in
DELETE_TEXT,
/* Binding actions */
ACTIVATE,
+ SET_EDITABLE,
MOVE_CURSOR,
MOVE_WORD,
MOVE_PAGE,
LAST_SIGNAL
};
+enum {
+ ARG_0,
+ ARG_TEXT_POSITION,
+ ARG_EDITABLE
+};
+
+
static void gtk_editable_class_init (GtkEditableClass *klass);
static void gtk_editable_init (GtkEditable *editable);
+static void gtk_editable_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_editable_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
static void gtk_editable_finalize (GtkObject *object);
static gint gtk_editable_selection_clear (GtkWidget *widget,
GdkEventSelection *event);
gint end);
static guint32 gtk_editable_get_event_time (GtkEditable *editable);
-static void gtk_real_editable_cut_clipboard (GtkEditable *editable);
-static void gtk_real_editable_copy_clipboard (GtkEditable *editable);
-static void gtk_real_editable_paste_clipboard (GtkEditable *editable);
+static void gtk_editable_real_cut_clipboard (GtkEditable *editable);
+static void gtk_editable_real_copy_clipboard (GtkEditable *editable);
+static void gtk_editable_real_paste_clipboard (GtkEditable *editable);
+static void gtk_editable_real_set_editable (GtkEditable *editable,
+ gboolean is_editable);
static void gtk_editable_marshal_signal_1 (GtkObject * object,
gint arg1,
gpointer data);
-guint
+GtkType
gtk_editable_get_type (void)
{
- static guint editable_type = 0;
+ static GtkType editable_type = 0;
if (!editable_type)
{
(GtkClassInitFunc) NULL,
};
- editable_type = gtk_type_unique (gtk_widget_get_type (), &editable_info);
+ editable_type = gtk_type_unique (GTK_TYPE_WIDGET, &editable_info);
}
return editable_type;
object_class = (GtkObjectClass*) class;
widget_class = (GtkWidgetClass*) class;
- parent_class = gtk_type_class (gtk_widget_get_type ());
+ parent_class = gtk_type_class (GTK_TYPE_WIDGET);
editable_signals[CHANGED] =
gtk_signal_new ("changed",
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
+ editable_signals[SET_EDITABLE] =
+ gtk_signal_new ("set-editable",
+ GTK_RUN_LAST | GTK_RUN_ACTION,
+ object_class->type,
+ GTK_SIGNAL_OFFSET (GtkEditableClass, set_editable),
+ gtk_editable_marshal_signal_3,
+ GTK_TYPE_NONE, 1,
+ GTK_TYPE_BOOL);
+
editable_signals[MOVE_CURSOR] =
gtk_signal_new ("move_cursor",
GTK_RUN_LAST | GTK_RUN_ACTION,
gtk_object_class_add_signals (object_class, editable_signals, LAST_SIGNAL);
+ gtk_object_add_arg_type ("GtkEditable::text_position", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_TEXT_POSITION);
+ gtk_object_add_arg_type ("GtkEditable::editable", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_EDITABLE);
+
+ object_class->set_arg = gtk_editable_set_arg;
+ object_class->get_arg = gtk_editable_get_arg;
object_class->finalize = gtk_editable_finalize;
widget_class->selection_clear_event = gtk_editable_selection_clear;
class->insert_text = NULL;
class->delete_text = NULL;
- class->changed = NULL;
+ class->changed = (void (*) (GtkEditable*)) gtk_widget_queue_draw;
class->activate = NULL;
+ class->set_editable = gtk_editable_real_set_editable;
class->move_cursor = NULL;
class->move_word = NULL;
class->kill_word = NULL;
class->kill_line = NULL;
- class->cut_clipboard = gtk_real_editable_cut_clipboard;
- class->copy_clipboard = gtk_real_editable_copy_clipboard;
- class->paste_clipboard = gtk_real_editable_paste_clipboard;
+ class->cut_clipboard = gtk_editable_real_cut_clipboard;
+ class->copy_clipboard = gtk_editable_real_copy_clipboard;
+ class->paste_clipboard = gtk_editable_real_paste_clipboard;
class->update_text = NULL;
class->get_chars = NULL;
class->set_position = NULL;
}
+static void
+gtk_editable_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkEditable *editable;
+
+ editable = GTK_EDITABLE (object);
+
+ switch (arg_id)
+ {
+ case ARG_TEXT_POSITION:
+ gtk_editable_set_position (editable, GTK_VALUE_INT (*arg));
+ break;
+ case ARG_EDITABLE:
+ gtk_editable_set_editable (editable, GTK_VALUE_BOOL (*arg));
+ break;
+ default:
+ break;
+ }
+}
+
+static void
+gtk_editable_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkEditable *editable;
+
+ editable = GTK_EDITABLE (object);
+
+ switch (arg_id)
+ {
+ case ARG_TEXT_POSITION:
+ GTK_VALUE_INT (*arg) = editable->current_pos;
+ break;
+ case ARG_EDITABLE:
+ GTK_VALUE_BOOL (*arg) = editable->editable;
+ break;
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
+}
+
static void
gtk_editable_init (GtkEditable *editable)
{
gint
gtk_editable_get_position (GtkEditable *editable)
{
+ g_return_val_if_fail (editable != NULL, -1);
+ g_return_val_if_fail (GTK_IS_EDITABLE (editable), -1);
+
return editable->current_pos;
}
guint start;
guint end;
+ g_return_if_fail (editable != NULL);
+ g_return_if_fail (GTK_IS_EDITABLE (editable));
+
if (!editable->editable)
return;
gboolean claim,
guint32 time)
{
+ g_return_if_fail (editable != NULL);
+ g_return_if_fail (GTK_IS_EDITABLE (editable));
g_return_if_fail (GTK_WIDGET_REALIZED (editable));
editable->has_selection = FALSE;
gint start,
gint end)
{
+ g_return_if_fail (editable != NULL);
+ g_return_if_fail (GTK_IS_EDITABLE (editable));
+
if (GTK_WIDGET_REALIZED (editable))
gtk_editable_claim_selection (editable, start != end, GDK_CURRENT_TIME);
void
gtk_editable_cut_clipboard (GtkEditable *editable)
{
+ g_return_if_fail (editable != NULL);
+ g_return_if_fail (GTK_IS_EDITABLE (editable));
+
gtk_signal_emit (GTK_OBJECT (editable), editable_signals[CUT_CLIPBOARD]);
}
void
gtk_editable_copy_clipboard (GtkEditable *editable)
{
+ g_return_if_fail (editable != NULL);
+ g_return_if_fail (GTK_IS_EDITABLE (editable));
+
gtk_signal_emit (GTK_OBJECT (editable), editable_signals[COPY_CLIPBOARD]);
}
void
gtk_editable_paste_clipboard (GtkEditable *editable)
{
+ g_return_if_fail (editable != NULL);
+ g_return_if_fail (GTK_IS_EDITABLE (editable));
+
gtk_signal_emit (GTK_OBJECT (editable), editable_signals[PASTE_CLIPBOARD]);
}
+void
+gtk_editable_set_editable (GtkEditable *editable,
+ gboolean is_editable)
+{
+ g_return_if_fail (editable != NULL);
+ g_return_if_fail (GTK_IS_EDITABLE (editable));
+
+ gtk_signal_emit (GTK_OBJECT (editable), editable_signals[SET_EDITABLE], is_editable != FALSE);
+}
+
static void
-gtk_real_editable_cut_clipboard (GtkEditable *editable)
+gtk_editable_real_set_editable (GtkEditable *editable,
+ gboolean is_editable)
{
- gtk_real_editable_copy_clipboard (editable);
- gtk_editable_delete_selection (editable);
+ g_return_if_fail (editable != NULL);
+ g_return_if_fail (GTK_IS_EDITABLE (editable));
+
+ editable->editable = is_editable != FALSE;
+ gtk_widget_queue_draw (GTK_WIDGET (editable));
}
static void
-gtk_real_editable_copy_clipboard (GtkEditable *editable)
+gtk_editable_real_cut_clipboard (GtkEditable *editable)
{
- guint32 time = gtk_editable_get_event_time (editable);
+ g_return_if_fail (editable != NULL);
+ g_return_if_fail (GTK_IS_EDITABLE (editable));
+
+ gtk_editable_real_copy_clipboard (editable);
+ gtk_editable_delete_selection (editable);
+}
+static void
+gtk_editable_real_copy_clipboard (GtkEditable *editable)
+{
+ guint32 time;
gint selection_start_pos;
gint selection_end_pos;
+ g_return_if_fail (editable != NULL);
+ g_return_if_fail (GTK_IS_EDITABLE (editable));
+
+ time = gtk_editable_get_event_time (editable);
selection_start_pos = MIN (editable->selection_start_pos, editable->selection_end_pos);
selection_end_pos = MAX (editable->selection_start_pos, editable->selection_end_pos);
}
static void
-gtk_real_editable_paste_clipboard (GtkEditable *editable)
+gtk_editable_real_paste_clipboard (GtkEditable *editable)
{
- guint32 time = gtk_editable_get_event_time (editable);
+ guint32 time;
+ g_return_if_fail (editable != NULL);
+ g_return_if_fail (GTK_IS_EDITABLE (editable));
+
+ time = gtk_editable_get_event_time (editable);
if (editable->editable)
gtk_selection_convert (GTK_WIDGET(editable),
clipboard_atom, ctext_atom, time);
void
gtk_editable_changed (GtkEditable *editable)
{
+ g_return_if_fail (editable != NULL);
+ g_return_if_fail (GTK_IS_EDITABLE (editable));
+
gtk_signal_emit (GTK_OBJECT (editable), editable_signals[CHANGED]);
}
#ifdef __cplusplus
extern "C" {
+#pragma }
#endif /* __cplusplus */
-#define GTK_EDITABLE(obj) GTK_CHECK_CAST (obj, gtk_editable_get_type (), GtkEditable)
-#define GTK_EDITABLE_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_editable_get_type (), GtkEditableClass)
-#define GTK_IS_EDITABLE(obj) GTK_CHECK_TYPE (obj, gtk_editable_get_type ())
+#define GTK_TYPE_EDITABLE (gtk_editable_get_type ())
+#define GTK_EDITABLE(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_EDITABLE, GtkEditable))
+#define GTK_EDITABLE_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_EDITABLE, GtkEditableClass))
+#define GTK_IS_EDITABLE(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_EDITABLE))
+#define GTK_IS_EDITABLE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_EDITABLE))
typedef struct _GtkEditable GtkEditable;
/* Bindings actions */
void (* activate) (GtkEditable *editable);
+ void (* set_editable) (GtkEditable *editable,
+ gboolean is_editable);
void (* move_cursor) (GtkEditable *editable,
gint x,
gint y);
gint position);
};
-guint gtk_editable_get_type (void);
+GtkType gtk_editable_get_type (void);
void gtk_editable_select_region (GtkEditable *editable,
gint start,
gint end);
void gtk_editable_delete_text (GtkEditable *editable,
gint start_pos,
gint end_pos);
-gchar * gtk_editable_get_chars (GtkEditable *editable,
+gchar* gtk_editable_get_chars (GtkEditable *editable,
gint start_pos,
gint end_pos);
void gtk_editable_cut_clipboard (GtkEditable *editable);
void gtk_editable_set_position (GtkEditable *editable,
gint position);
gint gtk_editable_get_position (GtkEditable *editable);
+void gtk_editable_set_editable (GtkEditable *editable,
+ gboolean is_editable);
#ifdef __cplusplus
#define DRAW_TIMEOUT 20
#define INNER_BORDER 2
+enum {
+ ARG_0,
+ ARG_MAX_LENGTH,
+ ARG_VISIBILITY,
+};
+
+
static void gtk_entry_class_init (GtkEntryClass *klass);
static void gtk_entry_init (GtkEntry *entry);
+static void gtk_entry_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_entry_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
static void gtk_entry_finalize (GtkObject *object);
static void gtk_entry_realize (GtkWidget *widget);
static void gtk_entry_unrealize (GtkWidget *widget);
};
-guint
+GtkType
gtk_entry_get_type (void)
{
- static guint entry_type = 0;
+ static GtkType entry_type = 0;
if (!entry_type)
{
(GtkClassInitFunc) NULL,
};
- entry_type = gtk_type_unique (gtk_editable_get_type (), &entry_info);
+ entry_type = gtk_type_unique (GTK_TYPE_EDITABLE, &entry_info);
}
return entry_type;
object_class = (GtkObjectClass*) class;
widget_class = (GtkWidgetClass*) class;
editable_class = (GtkEditableClass*) class;
+ parent_class = gtk_type_class (GTK_TYPE_EDITABLE);
- parent_class = gtk_type_class (gtk_editable_get_type ());
+ gtk_object_add_arg_type ("GtkEntry::max_length", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_MAX_LENGTH);
+ gtk_object_add_arg_type ("GtkEntry::visibility", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_VISIBILITY);
+ object_class->set_arg = gtk_entry_set_arg;
+ object_class->get_arg = gtk_entry_get_arg;
object_class->finalize = gtk_entry_finalize;
widget_class->realize = gtk_entry_realize;
editable_class->set_position = gtk_entry_set_position_from_editable;
}
+static void
+gtk_entry_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkEntry *entry;
+
+ entry = GTK_ENTRY (object);
+
+ switch (arg_id)
+ {
+ case ARG_MAX_LENGTH:
+ gtk_entry_set_max_length (entry, GTK_VALUE_UINT (*arg));
+ break;
+ case ARG_VISIBILITY:
+ gtk_entry_set_visibility (entry, GTK_VALUE_BOOL (*arg));
+ break;
+ default:
+ break;
+ }
+}
+
+static void
+gtk_entry_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkEntry *entry;
+
+ entry = GTK_ENTRY (object);
+
+ switch (arg_id)
+ {
+ case ARG_MAX_LENGTH:
+ GTK_VALUE_UINT (*arg) = entry->text_max_length;
+ break;
+ case ARG_VISIBILITY:
+ GTK_VALUE_BOOL (*arg) = entry->visible;
+ break;
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
+}
+
static void
gtk_entry_init (GtkEntry *entry)
{
GtkWidget*
gtk_entry_new (void)
{
- return GTK_WIDGET (gtk_type_new (gtk_entry_get_type ()));
+ return GTK_WIDGET (gtk_type_new (GTK_TYPE_ENTRY));
}
GtkWidget*
gtk_entry_new_with_max_length (guint16 max)
{
GtkEntry *entry;
- entry = gtk_type_new (gtk_entry_get_type ());
+
+ entry = gtk_type_new (GTK_TYPE_ENTRY);
entry->text_max_length = max;
+
return GTK_WIDGET (entry);
}
GTK_EDITABLE(entry)->current_pos = entry->text_length;
else
GTK_EDITABLE(entry)->current_pos = position;
+ gtk_entry_adjust_scroll (entry);
}
static void
void
gtk_entry_set_editable(GtkEntry *entry,
- gboolean editable)
+ gboolean editable)
{
g_return_if_fail (entry != NULL);
g_return_if_fail (GTK_IS_ENTRY (entry));
- GTK_EDITABLE (entry)->editable = editable;
- gtk_entry_queue_draw (entry);
+ gtk_editable_set_editable (GTK_EDITABLE (entry), editable);
}
gchar*
if (xoffset < 0)
entry->scroll_offset += xoffset;
-
else if (xoffset > text_area_width)
entry->scroll_offset += xoffset - text_area_width + 1;
+
+ gtk_widget_queue_draw (GTK_WIDGET (entry));
}
static void
#ifdef __cplusplus
extern "C" {
+#pragma }
#endif /* __cplusplus */
-#define GTK_ENTRY(obj) GTK_CHECK_CAST (obj, gtk_entry_get_type (), GtkEntry)
-#define GTK_ENTRY_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_entry_get_type (), GtkEntryClass)
-#define GTK_IS_ENTRY(obj) GTK_CHECK_TYPE (obj, gtk_entry_get_type ())
+#define GTK_TYPE_ENTRY (gtk_entry_get_type ())
+#define GTK_ENTRY(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_ENTRY, GtkEntry))
+#define GTK_ENTRY_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_ENTRY, GtkEntryClass))
+#define GTK_IS_ENTRY(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_ENTRY))
+#define GTK_IS_ENTRY_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ENTRY))
typedef struct _GtkEntry GtkEntry;
GtkEditableClass parent_class;
};
-guint gtk_entry_get_type (void);
-GtkWidget* gtk_entry_new (void);
-GtkWidget* gtk_entry_new_with_max_length (guint16 max);
-void gtk_entry_set_text (GtkEntry *entry,
- const gchar *text);
-void gtk_entry_append_text (GtkEntry *entry,
- const gchar *text);
-void gtk_entry_prepend_text (GtkEntry *entry,
- const gchar *text);
-void gtk_entry_set_position (GtkEntry *entry,
- gint position);
-gchar* gtk_entry_get_text (GtkEntry *entry);
-void gtk_entry_select_region (GtkEntry *entry,
- gint start,
- gint end);
-void gtk_entry_set_visibility (GtkEntry *entry,
- gboolean visible);
-void gtk_entry_set_editable (GtkEntry *entry,
- gboolean editable);
-void gtk_entry_adjust_scroll (GtkEntry *entry);
+GtkType gtk_entry_get_type (void);
+GtkWidget* gtk_entry_new (void);
+GtkWidget* gtk_entry_new_with_max_length (guint16 max);
+void gtk_entry_set_text (GtkEntry *entry,
+ const gchar *text);
+void gtk_entry_append_text (GtkEntry *entry,
+ const gchar *text);
+void gtk_entry_prepend_text (GtkEntry *entry,
+ const gchar *text);
+void gtk_entry_set_position (GtkEntry *entry,
+ gint position);
+gchar* gtk_entry_get_text (GtkEntry *entry);
+void gtk_entry_select_region (GtkEntry *entry,
+ gint start,
+ gint end);
+void gtk_entry_set_visibility (GtkEntry *entry,
+ gboolean visible);
+void gtk_entry_set_editable (GtkEntry *entry,
+ gboolean editable);
+void gtk_entry_adjust_scroll (GtkEntry *entry);
/* text is truncated if needed */
-void gtk_entry_set_max_length (GtkEntry *entry,
- guint16 max);
+void gtk_entry_set_max_length (GtkEntry *entry,
+ guint16 max);
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
switch (arg_id)
{
case ARG_LABEL:
- gtk_label_set (label, GTK_VALUE_STRING (*arg));
+ gtk_label_set (label, GTK_VALUE_STRING (*arg) ? GTK_VALUE_STRING (*arg) : "");
break;
case ARG_JUSTIFY:
gtk_label_set_justify (label, GTK_VALUE_ENUM (*arg));
STEP_NEXT
};
+enum {
+ ARG_0,
+ ARG_TAB_POS,
+ ARG_SHOW_TABS,
+ ARG_SHOW_BORDER,
+ ARG_SCROLLABLE,
+ ARG_TAB_BORDER,
+ ARG_PAGE,
+ ARG_ENABLE_POPUP
+};
+
+enum {
+ CHILD_ARG_0,
+ CHILD_ARG_TAB_LABEL,
+ CHILD_ARG_MENU_LABEL,
+ CHILD_ARG_POSITION
+};
+
typedef void (*GtkNotebookSignal) (GtkObject *object,
GtkNotebookPage *arg1,
gint arg2,
static void gtk_notebook_class_init (GtkNotebookClass *klass);
static void gtk_notebook_init (GtkNotebook *notebook);
+static void gtk_notebook_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_notebook_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_notebook_set_child_arg (GtkContainer *container,
+ GtkWidget *child,
+ GtkArg *arg,
+ guint arg_id);
+static void gtk_notebook_get_child_arg (GtkContainer *container,
+ GtkWidget *child,
+ GtkArg *arg,
+ guint arg_id);
static void gtk_notebook_destroy (GtkObject *object);
static void gtk_notebook_map (GtkWidget *widget);
static void gtk_notebook_unmap (GtkWidget *widget);
GtkWidget *widget);
static void gtk_notebook_real_remove (GtkNotebook *notebook,
GList *list,
- gint page_num);
+ guint page_num);
static void gtk_notebook_foreach (GtkContainer *container,
GtkCallback callback,
gpointer callback_data);
static void gtk_notebook_switch_page (GtkNotebook *notebook,
GtkNotebookPage *page,
- gint page_num);
+ guint page_num);
static void gtk_notebook_draw_tab (GtkNotebook *notebook,
GtkNotebookPage *page,
GdkRectangle *area);
GList *new_child);
static void gtk_real_notebook_switch_page (GtkNotebook *notebook,
GtkNotebookPage *page,
- gint page_num);
+ guint page_num);
static void gtk_notebook_marshal_signal (GtkObject *object,
GtkSignalFunc func,
gpointer func_data,
GtkNotebookPage *page);
static void gtk_notebook_update_labels (GtkNotebook *notebook,
GList *list,
- gint page_num);
+ guint page_num);
static void gtk_notebook_menu_detacher (GtkWidget *widget,
GtkMenu *menu);
static void gtk_notebook_menu_label_unparent (GtkWidget *widget,
object_class = (GtkObjectClass*) class;
widget_class = (GtkWidgetClass*) class;
container_class = (GtkContainerClass*) class;
-
parent_class = gtk_type_class (gtk_container_get_type ());
+ gtk_object_add_arg_type ("GtkNotebook::page", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_PAGE);
+ gtk_object_add_arg_type ("GtkNotebook::tab_pos", GTK_TYPE_POSITION_TYPE, GTK_ARG_READWRITE, ARG_TAB_POS);
+ gtk_object_add_arg_type ("GtkNotebook::tab_border", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_TAB_BORDER);
+ gtk_object_add_arg_type ("GtkNotebook::show_tabs", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_SHOW_TABS);
+ gtk_object_add_arg_type ("GtkNotebook::show_border", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_SHOW_BORDER);
+ gtk_object_add_arg_type ("GtkNotebook::scrollable", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_SCROLLABLE);
+ gtk_object_add_arg_type ("GtkNotebook::enable_popup", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_ENABLE_POPUP);
+
+ gtk_container_add_child_arg_type ("GtkNotebook::tab_label", GTK_TYPE_STRING, GTK_ARG_READWRITE, CHILD_ARG_TAB_LABEL);
+ /*
+ * gtk_container_add_child_arg_type ("GtkNotebook::menu_label", GTK_TYPE_STRING, GTK_ARG_READWRITE, CHILD_ARG_MENU_LABEL);
+ * gtk_container_add_child_arg_type ("GtkNotebook::position", GTK_TYPE_INT, GTK_ARG_READWRITE, CHILD_ARG_POSITION);
+ */
+
notebook_signals[SWITCH_PAGE] =
gtk_signal_new ("switch_page",
GTK_RUN_LAST,
gtk_notebook_marshal_signal,
GTK_TYPE_NONE, 2,
GTK_TYPE_POINTER,
- GTK_TYPE_INT);
+ GTK_TYPE_UINT);
gtk_object_class_add_signals (object_class, notebook_signals, LAST_SIGNAL);
+ object_class->set_arg = gtk_notebook_set_arg;
+ object_class->get_arg = gtk_notebook_get_arg;
object_class->destroy = gtk_notebook_destroy;
widget_class->map = gtk_notebook_map;
container_class->foreach = gtk_notebook_foreach;
container_class->focus = gtk_notebook_focus;
container_class->set_focus_child = gtk_notebook_set_focus_child;
+ container_class->get_child_arg = gtk_notebook_get_child_arg;
+ container_class->set_child_arg = gtk_notebook_set_child_arg;
container_class->child_type = gtk_notebook_child_type;
class->switch_page = gtk_real_notebook_switch_page;
}
+static void
+gtk_notebook_set_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkNotebook *notebook;
+
+ notebook = GTK_NOTEBOOK (object);
+
+ switch (arg_id)
+ {
+ case ARG_SHOW_TABS:
+ gtk_notebook_set_show_tabs (notebook, GTK_VALUE_BOOL (*arg));
+ break;
+ case ARG_SHOW_BORDER:
+ gtk_notebook_set_show_border (notebook, GTK_VALUE_BOOL (*arg));
+ break;
+ case ARG_SCROLLABLE:
+ gtk_notebook_set_scrollable (notebook, GTK_VALUE_BOOL (*arg));
+ break;
+ case ARG_ENABLE_POPUP:
+ if (GTK_VALUE_BOOL (*arg))
+ gtk_notebook_popup_enable (notebook);
+ else
+ gtk_notebook_popup_disable (notebook);
+ break;
+ case ARG_PAGE:
+ gtk_notebook_set_page (notebook, GTK_VALUE_INT (*arg));
+ break;
+ case ARG_TAB_POS:
+ gtk_notebook_set_tab_pos (notebook, GTK_VALUE_ENUM (*arg));
+ break;
+ case ARG_TAB_BORDER:
+ gtk_notebook_set_tab_border (notebook, GTK_VALUE_UINT (*arg));
+ break;
+ default:
+ break;
+ }
+}
+
+static void
+gtk_notebook_get_arg (GtkObject *object,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkNotebook *notebook;
+
+ notebook = GTK_NOTEBOOK (object);
+
+ switch (arg_id)
+ {
+ case ARG_SHOW_TABS:
+ GTK_VALUE_BOOL (*arg) = notebook->show_tabs;
+ break;
+ case ARG_SHOW_BORDER:
+ GTK_VALUE_BOOL (*arg) = notebook->show_border;
+ break;
+ case ARG_SCROLLABLE:
+ GTK_VALUE_BOOL (*arg) = notebook->scrollable;
+ break;
+ case ARG_ENABLE_POPUP:
+ GTK_VALUE_BOOL (*arg) = notebook->menu != NULL;
+ break;
+ case ARG_PAGE:
+ GTK_VALUE_INT (*arg) = gtk_notebook_current_page (notebook);
+ break;
+ case ARG_TAB_POS:
+ GTK_VALUE_ENUM (*arg) = notebook->tab_pos;
+ break;
+ case ARG_TAB_BORDER:
+ GTK_VALUE_UINT (*arg) = notebook->tab_border;
+ break;
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
+}
+
+static void
+gtk_notebook_set_child_arg (GtkContainer *container,
+ GtkWidget *child,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkNotebook *notebook;
+ GtkNotebookPage *page = NULL;
+ GList *list;
+
+ notebook = GTK_NOTEBOOK (container);
+
+ for (list = notebook->children; list; list = list->next)
+ {
+ page = list->data;
+ if (page->child == child)
+ break;
+ }
+ if (!list)
+ return;
+
+ switch (arg_id)
+ {
+ case CHILD_ARG_TAB_LABEL:
+ /* a NULL pointer indicates a default_tab setting, otherwise
+ * we need to set the associated label
+ */
+ if (GTK_VALUE_STRING (*arg))
+ {
+ page->default_tab = FALSE;
+ if (page->tab_label)
+ gtk_widget_unparent (page->tab_label);
+ page->tab_label = gtk_label_new (GTK_VALUE_STRING (*arg));
+ gtk_widget_set_parent (page->tab_label, GTK_WIDGET (notebook));
+ if (notebook->show_tabs)
+ gtk_widget_show (page->tab_label);
+ }
+ else
+ {
+ page->default_tab = TRUE;
+ if (page->tab_label)
+ gtk_widget_unparent (page->tab_label);
+ if (!notebook->show_tabs)
+ page->tab_label = NULL;
+ else
+ {
+ gchar string[32];
+
+ sprintf (string, "Page %u", g_list_index (notebook->children, page) + 1);
+ page->tab_label = gtk_label_new (string);
+ gtk_widget_set_parent (page->tab_label, GTK_WIDGET (notebook));
+ gtk_widget_show (page->tab_label);
+ }
+ }
+ break;
+ case CHILD_ARG_MENU_LABEL:
+ break;
+ case CHILD_ARG_POSITION:
+ break;
+ default:
+ break;
+ }
+}
+
+static void
+gtk_notebook_get_child_arg (GtkContainer *container,
+ GtkWidget *child,
+ GtkArg *arg,
+ guint arg_id)
+{
+ GtkNotebook *notebook;
+ GtkNotebookPage *page = NULL;
+ GList *list;
+
+ notebook = GTK_NOTEBOOK (container);
+
+ for (list = notebook->children; list; list = list->next)
+ {
+ page = list->data;
+ if (page->child == child)
+ break;
+ }
+ if (!list)
+ {
+ arg->type = GTK_TYPE_INVALID;
+ return;
+ }
+
+ switch (arg_id)
+ {
+ case CHILD_ARG_TAB_LABEL:
+ if (page->default_tab)
+ GTK_VALUE_STRING (*arg) = NULL;
+ else
+ {
+ if (page->tab_label && GTK_IS_LABEL (page->tab_label))
+ GTK_VALUE_STRING (*arg) = g_strdup (GTK_LABEL (page->tab_label)->label);
+ else
+ GTK_VALUE_STRING (*arg) = NULL;
+ }
+ break;
+ case CHILD_ARG_MENU_LABEL:
+ break;
+ case CHILD_ARG_POSITION:
+ break;
+ default:
+ arg->type = GTK_TYPE_INVALID;
+ break;
+ }
+}
+
static GtkType
gtk_notebook_child_type (GtkContainer *container)
{
void
gtk_notebook_remove_page (GtkNotebook *notebook,
- gint page_num)
+ gint page_num)
{
GList *list;
g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
- if ((list = g_list_nth (notebook->children, page_num)))
- gtk_notebook_real_remove (notebook, list, page_num);
+ if (page_num >= 0)
+ {
+ list = g_list_nth (notebook->children, page_num);
+ if (list)
+ gtk_notebook_real_remove (notebook, list, page_num);
+ }
+ else
+ {
+ list = g_list_last (notebook->children);
+ if (list)
+ gtk_notebook_real_remove (notebook, list,
+ g_list_index (notebook->children, list->data));
+ }
}
static void
GtkNotebook *notebook;
GtkNotebookPage *page;
GList *children;
- gint page_num;
+ guint page_num;
g_return_if_fail (container != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (container));
static void
gtk_notebook_real_remove (GtkNotebook *notebook,
GList *list,
- gint page_num)
+ guint page_num)
{
GtkNotebookPage *page;
GList * next_list;
void
gtk_notebook_set_page (GtkNotebook *notebook,
- gint page_num)
+ gint page_num)
{
GList *list;
-
+
g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
- if ((list = g_list_nth (notebook->children, page_num)))
- gtk_notebook_switch_page (notebook,
- ((GtkNotebookPage *)(list->data)), page_num);
+ if (page_num >= 0)
+ {
+ list = g_list_nth (notebook->children, page_num);
+ if (list)
+ gtk_notebook_switch_page (notebook, list->data, page_num);
+ }
+ else
+ {
+ list = g_list_last (notebook->children);
+ if (list)
+ gtk_notebook_switch_page (notebook, list->data,
+ g_list_index (notebook->children, list->data));
+ }
}
void
static void
gtk_real_notebook_switch_page (GtkNotebook *notebook,
GtkNotebookPage *page,
- gint page_num)
+ guint page_num)
{
g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
{
GtkNotebook *notebook;
GList *children;
- gint page_num;
+ guint page_num;
g_return_if_fail (widget != NULL);
g_return_if_fail (page != NULL);
static void
gtk_notebook_switch_page (GtkNotebook *notebook,
GtkNotebookPage *page,
- gint page_num)
+ guint page_num)
{
g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
void
gtk_notebook_set_tab_border (GtkNotebook *notebook,
- gint tab_border)
+ guint tab_border)
{
g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
- if (notebook->tab_border != tab_border && tab_border > 0)
+ if (notebook->tab_border != tab_border)
{
notebook->tab_border = tab_border;
static void
gtk_notebook_update_labels (GtkNotebook *notebook,
GList *list,
- gint page_num)
+ guint page_num)
{
GtkNotebookPage *page;
gchar string[32];
{
page = list->data;
list = list->next;
- sprintf (string, "Page %d", page_num);
+ sprintf (string, "Page %u", page_num);
if (notebook->show_tabs && page->default_tab)
gtk_label_set (GTK_LABEL (page->tab_label), string);
if (notebook->menu && page->default_menu)
guint32 timer;
- gint16 tab_border;
+ guint16 tab_border;
guint show_tabs : 1;
guint show_border : 1;
{
GtkContainerClass parent_class;
- void (* switch_page) (GtkNotebook *notebook,
+ void (* switch_page) (GtkNotebook *notebook,
GtkNotebookPage *page,
- gint page_num);
+ guint page_num);
};
struct _GtkNotebookPage
void gtk_notebook_set_scrollable (GtkNotebook *notebook,
gint scrollable);
void gtk_notebook_set_tab_border (GtkNotebook *notebook,
- gint border_width);
+ guint border_width);
void gtk_notebook_popup_enable (GtkNotebook *notebook);
void gtk_notebook_popup_disable (GtkNotebook *notebook);
static void gtk_text_disconnect (GtkAdjustment *adjustment,
GtkText *text);
-static void gtk_text_insert_text (GtkEditable *editable,
- const gchar *new_text,
- gint new_text_length,
- gint *position);
-static void gtk_text_delete_text (GtkEditable *editable,
- gint start_pos,
- gint end_pos);
-static void gtk_text_update_text (GtkEditable *editable,
- gint start_pos,
- gint end_pos);
-static gchar *gtk_text_get_chars (GtkEditable *editable,
- gint start,
- gint end);
-static void gtk_text_set_selection (GtkEditable *editable,
- gint start,
- gint end);
-
+static void gtk_text_insert_text (GtkEditable *editable,
+ const gchar *new_text,
+ gint new_text_length,
+ gint *position);
+static void gtk_text_delete_text (GtkEditable *editable,
+ gint start_pos,
+ gint end_pos);
+static void gtk_text_update_text (GtkEditable *editable,
+ gint start_pos,
+ gint end_pos);
+static gchar *gtk_text_get_chars (GtkEditable *editable,
+ gint start,
+ gint end);
+static void gtk_text_set_selection (GtkEditable *editable,
+ gint start,
+ gint end);
+static void gtk_text_real_set_editable (GtkEditable *editable,
+ gboolean is_editable);
+
/* Event handlers */
static void gtk_text_draw (GtkWidget *widget,
GdkRectangle *area);
/* Widget Crap */
/**********************************************************************/
-guint
+GtkType
gtk_text_get_type (void)
{
- static guint text_type = 0;
+ static GtkType text_type = 0;
if (!text_type)
{
(GtkClassInitFunc) NULL,
};
- text_type = gtk_type_unique (gtk_editable_get_type (), &text_info);
+ text_type = gtk_type_unique (GTK_TYPE_EDITABLE, &text_info);
}
return text_type;
widget_class = (GtkWidgetClass*) class;
editable_class = (GtkEditableClass*) class;
- parent_class = gtk_type_class (gtk_editable_get_type ());
+ parent_class = gtk_type_class (GTK_TYPE_EDITABLE);
object_class->destroy = gtk_text_destroy;
object_class->finalize = gtk_text_finalize;
widget_class->focus_in_event = gtk_text_focus_in;
widget_class->focus_out_event = gtk_text_focus_out;
+ editable_class->set_editable = gtk_text_real_set_editable;
editable_class->insert_text = gtk_text_insert_text;
editable_class->delete_text = gtk_text_delete_text;
{
GtkText *text;
- text = gtk_type_new (gtk_text_get_type ());
+ text = gtk_type_new (GTK_TYPE_TEXT);
gtk_text_set_adjustments (text, hadj, vadj);
void
gtk_text_set_editable (GtkText *text,
- gint editable)
+ gboolean is_editable)
{
- GtkWidget *widget;
-
g_return_if_fail (text != NULL);
g_return_if_fail (GTK_IS_TEXT (text));
- widget = GTK_WIDGET (text);
- GTK_EDITABLE(text)->editable = (editable != FALSE);
+ gtk_editable_set_editable (GTK_EDITABLE (text), is_editable);
+}
+
+static void
+gtk_text_real_set_editable (GtkEditable *editable,
+ gboolean is_editable)
+{
+ GtkText *text;
+
+ g_return_if_fail (editable != NULL);
+ g_return_if_fail (GTK_IS_TEXT (editable));
+
+ text = GTK_TEXT (editable);
+
+ editable->editable = (is_editable != FALSE);
- if (editable)
+ if (is_editable)
draw_cursor (text, TRUE);
else
undraw_cursor (text, TRUE);
#ifdef __cplusplus
extern "C" {
+#pragma }
#endif /* __cplusplus */
-#define GTK_TEXT(obj) GTK_CHECK_CAST (obj, gtk_text_get_type (), GtkText)
-#define GTK_TEXT_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_text_get_type (), GtkTextClass)
-#define GTK_IS_TEXT(obj) GTK_CHECK_TYPE (obj, gtk_text_get_type ())
-
+#define GTK_TYPE_TEXT (gtk_text_get_type ())
+#define GTK_TEXT(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_TEXT, GtkText))
+#define GTK_TEXT_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT, GtkTextClass))
+#define GTK_IS_TEXT(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_TEXT))
+#define GTK_IS_TEXT_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT))
+
typedef struct _GtkPropertyMark GtkPropertyMark;
typedef struct _GtkText GtkText;
typedef struct _GtkTextClass GtkTextClass;
};
-guint gtk_text_get_type (void);
+GtkType gtk_text_get_type (void);
GtkWidget* gtk_text_new (GtkAdjustment *hadj,
GtkAdjustment *vadj);
void gtk_text_set_editable (GtkText *text,
- gint editable);
+ gboolean editable);
void gtk_text_set_word_wrap (GtkText *text,
gint word_wrap);
void gtk_text_set_adjustments (GtkText *text,
projects / gtk4.git / commitdiff